Strategy Pattern

Strategy pattern က behavioral design pattern တစ်ခုပါ။ Strategy Pattern အကြောင်းပြောရရင် ပြဿနာ တစ်ခု ကို ဖြေရှင်းဖို့ အတွက် နည်းလမ်း မျိုးစုံ ရှိပါတယ်။ အဲဒီ နည်းလမ်းထဲက ဘယ် နည်းလမ်း နဲ့ ရှင်းမလဲ ဆိုတာကို ပြောပြပေးလိုက်တာပါပဲ။

ဥပမာ Google Map မှာ Point A ကနေ Point B ကို သွားမယ်။ အဲဒီ အခါမှာ သွားဖို့ Strategy တွေက

  1. ကား နဲ့ သွားမယ်
  2. လမ်းလျှောက် သွားမယ်
  3. bus နဲ့ သွားမယ်

ဆိုပြီး strategy ရှိလာပါတယ်။ Strategy ပေါ်မှာ မူတည်ပြီး Route ကို ဖန်တီး ပါတယ်။

Class Diagram ကို ကြည့်ရအောင်။

တကယ် အလုပ်လုပ်မည့် Sequence diagram ကို ကြည့်ရအောင်။

Sequence Diagram ကို မြင်သည့် အခါမှာ code ကို သဘောပေါက်ပါလိမ့်မယ်။

အခု Code ကို ကြည့်ရအောင်။

RouteStrategy.java

interface RouteStrategy {
    void calculateRoute(String startPoint, String endPoint);
}

CarRouteStrategy.java

class CarRouteStrategy implements RouteStrategy {
    @Override
    public void calculateRoute(String startPoint, String endPoint) {
        System.out.println("Calculating car route from " + startPoint + " to " + endPoint);
    }
}

BusRouteStrategy.java

class BusRouteStrategy implements RouteStrategy {
    @Override
    public void calculateRoute(String startPoint, String endPoint) {
        System.out.println("Calculating bus route from " + startPoint + " to " + endPoint);
    }
}

WalkRouteStrategy.java

class WalkRouteStrategy implements RouteStrategy {
    @Override
    public void calculateRoute(String startPoint, String endPoint) {
        System.out.println("Calculating walking route from " + startPoint + " to " + endPoint);
    }
}

**

NavigationContext.java**

class NavigationContext {
    
   private RouteStrategy routeStrategy;

   public NavigationContext(RouteStrategy routeStrategy){
       this.routeStrategy = routeStrategy;
   }

   public void setRouteStrategy(RouteStrategy strategy){
       this.routeStrategy = strategy;
   }

   public void calculateRoute(String startPoint, String endPoint){
       this.routeStrategy.calculateRoute(startPoint,endPoint);
   }
}

Application.java

public class Application {
    public static void main(String[] args) {
        // Create a new BusRouteStrategy
        RouteStrategy busRouteStrategy = new BusRouteStrategy();

        // Create a new NavigationContext and set the strategy to BusRouteStrategy
        NavigationContext navigationContext = new NavigationContext(busRouteStrategy);

        // Use the navigationContext to calculate a route
        navigationContext.calculateRoute("Start Point", "End Point");

        RouteStrategy carRouteStrategy = new CarRouteStrategy();
        navigationContext.setRouteStrategy(carRouteStrategy);
        navigationContext.calculateRoute("Start Point", "End Point");

        RouteStrategy walkRouteStrategy = new WalkRouteStrategy();
        navigationContext.setRouteStrategy(walkRouteStrategy);
        navigationContext.calculateRoute("Start Point", "End Point");

    }
}

Strategy Pattern ကို တခြား ဥပမာ အနေနဲ့ ပြောရရင်  Array Sorting တွေကို strategy pattern နဲ့ ဘယ် sorting ကို သုံးမလဲ ဆိုတာကို ထည့်နိုင်ပါတယ်။

အခု ဆိုရင် class diagram ကြည့်တာနဲ့ code ဘယ်လို ရေးရမလဲ သဘောပေါက်ပြီလို့ ထင်ပါတယ်။

SortStrategy.java

// Strategy interface
interface SortStrategy {
    void sort(int[] array);
}

BubbleSort.java

// Concrete Strategy: BubbleSort
class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("BubbleSort applied.");
    }
}

QuickSort.java

// Concrete Strategy: QuickSort
class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("QuickSort applied.");
    }
}

MergeSort.java

// Concrete Strategy: MergeSort
class MergeSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("MergeSort applied.");
    }
}

Products.java

// Context class
class Products {
    private int[] array;
    private SortStrategy sortStrategy;

    public Products(int[] array) {
        this.array = array;
    }

    public void setSortStrategy(SortStrategy sortStrategy) {
        this.sortStrategy = sortStrategy;
    }

    public void sort() {
        sortStrategy.sort(array);
    }

    public void display() {
        System.out.print("Sorted array: ");
        for (int num : array) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        int[] array = { 64, 34, 25, 12, 22, 11, 90 };

        Products products = new Products(array);

        // Sort using BubbleSort
        products.setSortStrategy(new BubbleSort());
        products.sort();
        products.display();

        // Sort using QuickSort
        products.setSortStrategy(new QuickSort());
        products.sort();
        products.display();

        // Sort using MergeSort
        products.setSortStrategy(new MergeSort());
        products.sort();
        products.display();
    }
}

Strategy Pattern ကို တော်တော်များများ မှာ အသုံးပြုတာကို တွေ့နိုင်တယ်။ ဥပမာ Sign In with Google, Sign In With Facebook တို့ ဆိုရင် strategy pattern နဲ့ ခွဲထုတ်ပြီး ရေးသားနိုင်ပါတယ်။ 

Pros and Cons

ကောင်းတာတွေကတော့

  • Runtime မှာ သက်ဆိုင်ရာ algorithms ကို ပြောင်းလဲ အသုံးပြုနိုင်ပါတယ်။ ဥပမာ Bus Route, Car Route လိုမျိုးပေါ့။
  • Open/Closed Principle ကိုလည်း follow လုပ်ထားပါတယ်။

မကောင်းတာကတော့

  • Algorithm တွေ ပြောင်းဖို့ မလိုသည့် project တွေမှာ ဆိုရင် သုံးဖို့ မလိုအပ်ပါဘူး။